/**
 * 运费计算系统统一API服务
 *
 * 该模块提供系统所有后端API接口的统一访问入口，采用ES6模块化设计，
 * 支持统一的错误处理、请求拦截和响应处理。
 *
 * 功能特性：
 * - 统一的HTTP请求封装（GET、POST、PUT、DELETE）
 * - 完整的错误处理机制
 * - 区域管理API
 * - 策略管理API
 * - 运费计算API
 * - 重量区间规则API
 * - 策略区域定价映射API
 * - 策略分配API
 * - 操作日志API
 * - 请求超时处理
 * - 第三方脚本干扰防护
 *
 * 技术栈：
 * - ES6 Modules
 * - Axios HTTP客户端
 * - Promise/async-await
 *
 * @author 运费系统团队
 * @version 2.0.0
 * @since 2025-08-29
 * @module ApiService
 */

// 使用全局 ErrorHandler（从 utils.js 中获取）
// 确保 utils.js 已经加载

/**
 * API服务类
 *
 * 负责封装所有HTTP请求，提供统一的接口访问方式。
 * 采用单例模式设计，确保全局只有一个API服务实例。
 *
 * 主要特性：
 * - 支持RESTful API设计原则
 * - 自动错误处理和重试机制
 * - 请求超时控制（默认10秒）
 * - 第三方脚本干扰防护
 * - JSON数据格式统一处理
 *
 * @class ApiService
 * @example
 * // 创建实例
 * const apiService = new ApiService('/api');
 *
 * // 使用GET请求
 * const areas = await apiService.getAreas();
 *
 * // 使用POST请求
 * const result = await apiService.addArea(areaData);
 */
// 将 ApiService 暴露到全局作用域
window.ApiService = class ApiService {
    /**
     * 构造函数
     *
     * @param {string} [baseURL=''] - API基础URL，默认为空字符串
     * @throws {Error} 当axios库未加载时抛出错误
     */
    constructor(baseURL = '/freight') {
        /** @type {string} API基础URL */
        this.baseURL = baseURL;
        /** @type {number} 请求超时时间（毫秒） */
        this.timeout = 10000; // 10 seconds
        /** @type {number} 最大重试次数 */
        this.maxRetries = 3;
        /** @type {number} 重试延迟时间（毫秒） */
        this.retryDelay = 1000;
        /** @type {Array<number>} 可重试的HTTP状态码 */
        this.retryableStatusCodes = [408, 429, 500, 502, 503, 504];

        // 检查axios是否可用
        if (typeof axios === 'undefined') {
            console.error('❌ axios库未加载或不可用');
            throw new Error('axios库未加载，请检查网络连接或刷新页面');
        }

        console.log('✅ ApiService构造函数执行成功，axios可用');
    }

    /**
     * 发起HTTP请求的核心方法
     *
     * 该方法封装了axios请求，提供统一的错误处理、超时控制、重试机制和日志记录。
     * 自动设置JSON请求头，支持第三方脚本干扰防护。
     *
     * @param {string} method - HTTP请求方法（GET、POST、PUT、DELETE）
     * @param {string} url - 请求URL路径（相对于baseURL）
     * @param {Object|null} [data=null] - 请求数据体（POST/PUT请求使用）
     * @param {number} [retryCount=0] - 当前重试次数
     * @returns {Promise<Object>} 返回响应数据对象
     * @throws {Error} 当请求失败或axios不可用时抛出错误
     *
     * @example
     * // GET请求
     * const data = await apiService.request('GET', '/areas');
     *
     * // POST请求
     * const result = await apiService.request('POST', '/areas', { name: '北京市' });
     */
    async request(method, url, data = null, retryCount = 0) {
        try {
            // 再次检查axios是否可用
            if (typeof axios === 'undefined') {
                console.error('❌ 请求执行时axios不可用');
                throw new Error('axios库不可用，请刷新页面重试');
            }

            console.log(`🔧 发起${method}请求:`, url, data ? '有数据' : '无数据', retryCount > 0 ? `(重试第${retryCount}次)` : '');

            const config = {
                method,
                url: `${this.baseURL}${url}`,
                headers: { 'Content-Type': 'application/json;charset=UTF-8' },
                timeout: this.timeout
            };

            if (data) {
                config.data = data;
            }

            // Suppress third-party script interference temporarily
            const originalConsoleError = console.error;
            console.error = function(...args) {
                if (!args[0] || typeof args[0] !== 'string' ||
                    (!args[0].includes('stadium.js') &&
                     !args[0].includes('iframe.js') &&
                     !args[0].includes('user.js'))) {
                    originalConsoleError.apply(console, args);
                }
            };

            const response = await axios(config);

            // Restore console.error
            console.error = originalConsoleError;

            // 检查响应格式
            if (response.data && response.data.code !== undefined) {
                if (response.data.code !== 0) {
                    console.warn(`⚠️ API返回业务错误: ${response.data.msg || '未知错误'}`);
                }
            }

            return response.data;
        } catch (error) {
            console.error(`API请求失败 (${method} ${url}):`, error);

            // 判断是否需要重试
            if (this.shouldRetry(error, retryCount)) {
                const delay = this.calculateRetryDelay(retryCount);
                console.log(`🔄 ${delay}ms后进行第${retryCount + 1}次重试...`);

                await this.sleep(delay);
                return this.request(method, url, data, retryCount + 1);
            }

            // 处理最终错误
            const errorMessage = ErrorHandler.handleApiError(error);
            throw new Error(errorMessage);
        }
    }

    /**
     * 判断是否应该重试请求
     *
     * @param {Error} error - 错误对象
     * @param {number} retryCount - 当前重试次数
     * @returns {boolean} 是否应该重试
     */
    shouldRetry(error, retryCount) {
        // 超出最大重试次数
        if (retryCount >= this.maxRetries) {
            return false;
        }

        // 网络错误
        if (error.code === 'NETWORK_ERROR' || error.code === 'ECONNABORTED') {
            return true;
        }

        // HTTP状态码错误
        if (error.response && this.retryableStatusCodes.includes(error.response.status)) {
            return true;
        }

        // 超时错误
        if (error.code === 'ECONNABORTED' || error.message.includes('timeout')) {
            return true;
        }

        return false;
    }

    /**
     * 计算重试延迟时间（指数退避）
     *
     * @param {number} retryCount - 当前重试次数
     * @returns {number} 延迟时间（毫秒）
     */
    calculateRetryDelay(retryCount) {
        return Math.min(this.retryDelay * Math.pow(2, retryCount), 10000); // 最大延迟10秒
    }

    /**
     * 延迟工具方法
     *
     * @param {number} ms - 延迟时间（毫秒）
     * @returns {Promise<void>}
     */
    sleep(ms) {
        return new Promise(resolve => setTimeout(resolve, ms));
    }

    // ==========================================
    // HTTP方法快捷方式
    // ==========================================

    /**
     * 发起GET请求
     * @param {string} url - 请求URL路径
     * @returns {Promise<Object>} 响应数据
     */
    get(url) {
        return this.request('GET', url);
    }

    /**
     * 发起POST请求
     * @param {string} url - 请求URL路径
     * @param {Object} data - 请求数据体
     * @returns {Promise<Object>} 响应数据
     */
    post(url, data) {
        return this.request('POST', url, data);
    }

    /**
     * 发起PUT请求
     * @param {string} url - 请求URL路径
     * @param {Object} data - 请求数据体
     * @returns {Promise<Object>} 响应数据
     */
    put(url, data) {
        return this.request('PUT', url, data);
    }

    /**
     * 发起DELETE请求
     * @param {string} url - 请求URL路径
     * @returns {Promise<Object>} 响应数据
     */
    delete(url) {
        return this.request('DELETE', url);
    }

    // ==========================================
    // 区域管理API
    // ==========================================

    /**
     * 获取区域列表（不分页）
     *
     * 用于获取所有区域数据，通常用于下拉选择框或级联选择器。
     * 支持按省市区三级结构返回数据。
     *
     * @param {Object} [query={}] - 查询条件
     * @param {string} [query.provinceName] - 省份名称
     * @param {string} [query.cityName] - 城市名称
     * @param {string} [query.districtName] - 区县名称
     * @param {number} [query.level] - 区域级别（1-省份，2-城市，3-区县）
     * @returns {Promise<Object>} 区域数据列表
     *
     * @example
     * // 获取所有区域
     * const areas = await api.getAreas();
     *
     * // 获取北京市的所有区县
     * const beijingAreas = await api.getAreas({ provinceName: '北京市', level: 3 });
     */
    async getAreas(query = {}) {
        return await this.post('/area/list', query);
    }

    /**
     * 获取区域列表（分页）
     *
     * 用于区域管理页面的分页显示，支持排序、筛选和搜索。
     *
     * @param {Object} [query={}] - 查询条件
     * @param {number} [query.currentPage=1] - 当前页码
     * @param {number} [query.pageSize=10] - 每页数量
     * @param {string} [query.provinceName] - 省份名称
     * @param {string} [query.cityName] - 城市名称
     * @param {string} [query.districtName] - 区县名称
     * @returns {Promise<Object>} 分页区域数据
     */
    async getAreasWithPage(query = {}) {
        return await this.post('/area/list-page', query);
    }

    /**
     * 获取区域树形结构数据
     *
     * 用于获取完整的省市区三级联动树形结构数据，主要用于区域缓存管理器和选择器组件。
     * 返回的数据结构为嵌套的树形结构，包含省、市、区三级层次。
     *
     * @param {Object} [query={}] - 查询条件（可选）
     * @param {string} [query.provinceName] - 省份名称筛选
     * @param {number} [query.level] - 层级限制（1-省，2-市，3-区）
     * @returns {Promise<Object>} 树形区域数据
     *
     * @example
     * // 获取完整区域树
     * const areaTree = await api.getAreaTree();
     *
     * // 获取指定省份的区域树
     * const beijingTree = await api.getAreaTree({ provinceName: '北京市' });
     */
    async getAreaTree(query = {}) {
        return await this.post('/area/list-tree', query);
    }

    /**
     * 根据ID获取区域详细信息
     *
     * 用于获取指定区域ID的详细信息，包括省市区完整信息和层级关系。
     * 主要用于区域缓存管理器中的缓存补充和区域名称显示。
     *
     * @param {number} areaId - 区域ID
     * @returns {Promise<Object>} 区域详细信息
     *
     * @example
     * // 获取指定区域信息
     * const areaInfo = await api.getAreaById(123);
     * console.log(areaInfo.data.provinceName); // 省份名称
     * console.log(areaInfo.data.cityName);     // 城市名称
     * console.log(areaInfo.data.districtName); // 区县名称
     */
    async getAreaById(areaId) {
        return await this.post('/area/get-by-id', { id: parseInt(areaId) });
    }

    /**
     * 导出区域数据
     *
     * 按照指定的查询条件导出区域数据为Excel文件。
     * 支持按省、市、区等条件进行筛选导出。
     *
     * @param {Object} [query={}] - 导出条件
     * @param {string} [query.provinceName] - 省份名称筛选
     * @param {string} [query.cityName] - 城市名称筛选
     * @param {string} [query.districtName] - 区县名称筛选
     * @param {number} [query.level] - 区域级别筛选
     * @returns {Promise<Blob>} Excel文件数据流
     *
     * @example
     * // 导出所有区域数据
     * const blob = await api.exportAreas();
     *
     * // 导出指定省份的区域数据
     * const blob = await api.exportAreas({ provinceName: '北京市' });
     */
    async exportAreas(query = {}) {
        // 注意：导出接口返回的是文件流，不是JSON数据
        const response = await fetch(`${this.baseURL}/area/export`, {
            method: 'POST',
            headers: {
                'Content-Type': 'application/json;charset=UTF-8',
            },
            body: JSON.stringify(query)
        });

        if (!response.ok) {
            throw new Error(`导出失败: ${response.status} ${response.statusText}`);
        }

        return response; // 返回原始响应对象，以便获取文件名等信息
    }

    /**
     * 新增区域
     *
     * @param {Object} areaData - 区域数据
     * @param {string} areaData.provinceName - 省份名称
     * @param {string} areaData.cityName - 城市名称
     * @param {string} areaData.districtName - 区县名称
     * @param {number} areaData.level - 区域级别
     * @returns {Promise<Object>} 新增结果
     */
    async addArea(areaData) {
        return await this.post('/area/add', areaData);
    }

    /**
     * 更新区域
     *
     * @param {Object} areaData - 区域数据
     * @param {number} areaData.id - 区域ID
     * @param {string} areaData.provinceName - 省份名称
     * @param {string} areaData.cityName - 城市名称
     * @param {string} areaData.districtName - 区县名称
     * @returns {Promise<Object>} 更新结果
     */
    async updateArea(areaData) {
        return await this.post('/area/update', areaData);
    }

    /**
     * 删除区域
     *
     * 支持两种调用方式：
     * 1. 传入对象：deleteArea({ areaId: 123 })
     * 2. 直接传入ID：deleteArea(123)
     *
     * @param {Object|number} deleteData - 删除数据或区域ID
     * @returns {Promise<Object>} 删除结果
     */
    async deleteArea(deleteData) {
        // 支持两种调用方式：
        // 1. deleteArea({ areaId: 123 })
        // 2. deleteArea(123)
        const requestData = typeof deleteData === 'object' ? deleteData : { areaId: deleteData };
        return await this.post('/area/delete', requestData);
    }

    // ==========================================
    // 策略管理API
    // ==========================================

    /**
     * 获取运费策略列表
     *
     * 支持按名称、状态等条件进行筛选查询。
     *
     * @param {Object} [query={}] - 查询条件
     * @param {string} [query.name] - 策略名称（模糊查询）
     * @param {number} [query.status] - 策略状态（1-启用，0-禁用）
     * @param {string} [query.pricingModel] - 计费模式（FIRST_WEIGHT_ADDITIONAL、WEIGHT_SEGMENT）
     * @returns {Promise<Object>} 策略列表数据
     *
     * @example
     * // 获取所有策略
     * const strategies = await api.getStrategies();
     *
     * // 获取启用状态的策略
     * const activeStrategies = await api.getStrategies({ status: 1 });
     */
    async getStrategies(query = {}) {
        return await this.post('/strategy/list', query);
    }

    /**
     * 新增运费策略
     *
     * @param {Object} strategyData - 策略数据
     * @param {string} strategyData.name - 策略名称
     * @param {string} [strategyData.description] - 策略描述
     * @param {string} strategyData.pricingModel - 计费模式
     * @param {number} [strategyData.status=1] - 策略状态
     * @returns {Promise<Object>} 新增结果
     */
    async addStrategy(strategyData) {
        return await this.post('/strategy/add', strategyData);
    }

    /**
     * 更新运费策略
     *
     * @param {Object} strategyData - 策略数据
     * @param {number} strategyData.id - 策略ID
     * @param {string} strategyData.name - 策略名称
     * @param {string} [strategyData.description] - 策略描述
     * @param {number} [strategyData.status] - 策略状态
     * @returns {Promise<Object>} 更新结果
     */
    async updateStrategy(strategyData) {
        return await this.post('/strategy/edit', strategyData);
    }

    /**
     * 删除运费策略
     *
     * @param {number} strategyId - 策略ID
     * @returns {Promise<Object>} 删除结果
     */
    async deleteStrategy(strategyId) {
        return await this.post('/strategy/delete', { id: strategyId });
    }


    /**
     * 获取运费策略详情
     *
     * 获取指定策略的完整信息，包括地区配置和重量区间规则
     *
     * @param {number} strategyId - 策略ID
     * @returns {Promise<Object>} 策略详情数据
     *
     * @example
     * // 获取策略详情
     * const strategyDetail = await api.getStrategyDetail(123);
     */
    async getStrategyDetail(strategyId) {
        return await this.get(`/strategy/detail/${strategyId}`);
    }

    /**
     * 复制策略数据
     * <pre>
     * 复制指定策略的所有配置信息（包括地区配置和重量区间规则），
     * 创建新的策略并返回新策略的ID
     *
     * @param {Object} copyData - 复制数据
     * @param {number} copyData.sourceStrategyId - 源策略ID
     * @param {string} copyData.newName - 新策略名称
     * @param {string} [copyData.description] - 新策略描述
     * @param {string} [copyData.operator] - 操作人
     * @returns {Promise<Object>} 复制结果，包含新策略ID
     *
     * @example
     * // 复制策略
     * const result = await api.copyStrategyData({
     *     sourceStrategyId: 123,
     *     newName: '新策略名称',
     *     description: '策略描述',
     *     operator: 'admin'
     * });
     */
    async copyStrategyData(copyData) {
        return await this.post('/strategy/copy-data', copyData);
    }


    // ==========================================
    // 运费计算API
    // ==========================================

    /**
     * 计算运费（智能策略匹配）
     *
     * 系统会根据目标区域、仓库和物流公司自动匹配最优策略。
     * 支持地址层级匹配：精确ID > 区县 > 城市 > 省份。
     *
     * @param {Object} calculationData - 计算参数
     * @param {number} [calculationData.toAreaId] - 目标区域ID（精确匹配）
     * @param {string} [calculationData.toProvinceName] - 目标省份（层级匹配）
     * @param {string} [calculationData.toCityName] - 目标城市（层级匹配）
     * @param {string} [calculationData.toDistrictName] - 目标区县（层级匹配）
     * @param {number} calculationData.weight - 货物重量（kg）
     * @param {number} [calculationData.length] - 货物长度（cm）
     * @param {number} [calculationData.width] - 货物宽度（cm）
     * @param {number} [calculationData.height] - 货物高度（cm）
     * @param {string} [calculationData.warehouseCode] - 仓库编码
     * @param {string} [calculationData.logisticsCompanyCode] - 物流公司编码
     * @returns {Promise<Object>} 运费计算结果
     *
     * @example
     * // 基本计算
     * const result = await api.calculateFreight({
     *   toAreaId: 1001,
     *   weight: 2.5
     * });
     *
     * // 层级匹配计算
     * const result = await api.calculateFreight({
     *   toProvinceName: '北京市',
     *   toCityName: '北京市',
     *   toDistrictName: '朝阳区',
     *   weight: 2.5,
     *   warehouseCode: 'WH001'
     * });
     */
    async calculateFreight(calculationData) {
        // 支持新的地址层级参数：toProvinceName, toCityName, toDistrictName
        return await this.post('/freight/calculate', calculationData);
    }

    /**
     * 按指定策略计算运费
     *
     * 使用指定的策略ID进行运费计算，跳过策略匹配步骤。
     *
     * @param {number} strategyId - 策略ID
     * @param {Object} calculationData - 计算参数（同 calculateFreight）
     * @returns {Promise<Object>} 运费计算结果
     *
     * @deprecated 使用 calculateFreight 并在请求体中设置 strategyId
     */
    async calculateFreightWithStrategy(strategyId, calculationData) {
        // V2.0: 使用统一的 /freight/calculate 接口，在请求体中设置 strategyId
        const requestData = {
            ...calculationData,
            strategyId: strategyId
        };
        return await this.post('/freight/calculate', requestData);
    }

    // ==========================================
    // 重量区间规则API
    // ==========================================

    /**
     * 获取策略的重量区间规则列表
     *
     * @param {number} strategyId - 策略ID
     * @returns {Promise<Object>} 重量规则列表
     */
    async getWeightRules(strategyId) {
        return await this.post('/weight-segment-rule/list', { strategyId });
    }

    /**
     * 新增重量区间规则
     *
     * @param {Object} ruleData - 规则数据
     * @param {number} ruleData.strategyId - 策略ID
     * @param {number} ruleData.upperBound - 重量上限（kg）
     * @param {number} ruleData.freight - 区间费用（元）
     * @returns {Promise<Object>} 新增结果
     */
    async addWeightRule(ruleData) {
        return await this.post('/weight-segment-rule/add', ruleData);
    }

    /**
     * 更新重量区间规则
     *
     * @param {Object} ruleData - 规则数据
     * @param {number} ruleData.id - 规则ID
     * @param {number} ruleData.upperBound - 重量上限（kg）
     * @param {number} ruleData.freight - 区间费用（元）
     * @returns {Promise<Object>} 更新结果
     */
    async updateWeightRule(ruleData) {
        return await this.post('/weight-segment-rule/update', ruleData);
    }

    /**
     * 删除重量区间规则
     *
     * @param {number} ruleId - 规则ID
     * @returns {Promise<Object>} 删除结果
     */
    async deleteWeightRule(ruleId) {
        return await this.post('/weight-segment-rule/delete', { id: ruleId });
    }

    // ==========================================
    // 策略区域定价映射API
    // ==========================================

    /**
     * 获取映射关系列表
     *
     * @param {number|null} [strategyId=null] - 策略ID，为null时获取所有映射
     * @returns {Promise<Object>} 映射关系列表
     */
    async getMappings(strategyId = null) {
        const params = strategyId ? { strategyId } : {};
        return await this.post('/api/pricing-area-mapping/list', params);
    }

    /**
     * 获取合并后的映射列表
     *
     * 将相同策略和区域的多个映射合并显示。
     *
     * @param {Object} [query={}] - 查询条件
     * @returns {Promise<Object>} 合并后的映射列表
     */
    async getMappingsMerged(query = {}) {
        return await this.post('/api/pricing-area-mapping/merged-list', query);
    }

    /**
     * 获取按区域分组的映射列表
     *
     * @param {Object} [query={}] - 查询条件
     * @returns {Promise<Object>} 按区域分组的映射列表
     */
    async getMappingsGroupByArea(query = {}) {
        return await this.post('/api/pricing-area-mapping/group-by-area-list', query);
    }

    /**
     * 新增映射关系
     *
     * @param {Object} mappingData - 映射数据
     * @param {number} mappingData.strategyId - 策略ID
     * @param {number} mappingData.areaId - 区域ID
     * @param {number[]} mappingData.segmentRuleIds - 重量规则ID数组
     * @returns {Promise<Object>} 新增结果
     */
    async addMapping(mappingData) {
        return await this.post('/api/pricing-area-mapping/add', mappingData);
    }

    /**
     * 批量新增映射关系
     *
     * @param {Object} batchMappingData - 批量映射数据
     * @param {number} batchMappingData.strategyId - 策略ID
     * @param {number[]} batchMappingData.areaIds - 区域ID数组
     * @param {number[]} batchMappingData.segmentRuleIds - 重量规则ID数组
     * @returns {Promise<Object>} 批量新增结果
     */
    async addBatchMappings(batchMappingData) {
        return await this.post('/api/pricing-area-mapping/batch-add', batchMappingData);
    }

    /**
     * 删除映射关系
     *
     * @param {number} mappingId - 映射ID
     * @returns {Promise<Object>} 删除结果
     */
    async deleteMapping(mappingId) {
        return await this.post('/api/pricing-area-mapping/delete', { id: mappingId });
    }

    /**
     * 批量删除映射关系
     *
     * @param {number[]} mappingIds - 映射ID数组
     * @returns {Promise<Object>} 批量删除结果
     */
    async batchDeleteMappings(mappingIds) {
        return await this.post('/api/pricing-area-mapping/batch-delete', { mappingIds });
    }

    // ==========================================
    // 策略分配API
    // ==========================================

    /**
     * 获取策略分配列表
     *
     * 用于查询策略与仓库、物流公司的分配关系。
     *
     * @param {Object} [query={}] - 查询条件
     * @param {number} [query.strategyId] - 策略ID
     * @param {string} [query.warehouseCode] - 仓库编码
     * @param {string} [query.logisticsCompanyCode] - 物流公司编码
     * @param {number} [query.status] - 分配状态（1-启用，0-禁用）
     * @returns {Promise<Object>} 策略分配列表
     */
    async getAssignments(query = {}) {
        return await this.post('/strategy-assignment/list', query);
    }

    /**
     * 新增策略分配
     *
     * 将策略分配给指定的仓库和物流公司组合。
     *
     * @param {Object} assignmentData - 分配数据
     * @param {number} assignmentData.strategyId - 策略ID
     * @param {string} assignmentData.warehouseCode - 仓库编码
     * @param {string} assignmentData.logisticsCompanyCode - 物流公司编码
     * @param {number} [assignmentData.priority=1] - 优先级（数字越小优先级越高）
     * @param {number} [assignmentData.status=1] - 分配状态
     * @returns {Promise<Object>} 新增结果
     */
    async addAssignment(assignmentData) {
        return await this.post('/strategy-assignment/assign', assignmentData);
    }

    /**
     * 批量新增策略分配
     *
     * 将多个策略分配给指定的仓库和物流公司组合。
     *
     * @param {Object} batchAssignmentData - 批量分配数据
     * @param {number[]} batchAssignmentData.strategyIds - 策略ID数组
     * @param {string} batchAssignmentData.warehouseCode - 仓库编码
     * @param {string} batchAssignmentData.logisticsCompanyCode - 物流公司编码
     * @param {number} [batchAssignmentData.priority=1] - 优先级
     * @returns {Promise<Object>} 批量新增结果
     */
    async batchAssign(batchAssignmentData) {
        return await this.post('/strategy-assignment/batch-assign', batchAssignmentData);
    }

    /**
     * 删除策略分配
     *
     * @param {number} assignmentId - 分配ID
     * @returns {Promise<Object>} 删除结果
     */
    async deleteAssignment(assignmentId) {
        return await this.post('/strategy-assignment/delete', { id: assignmentId });
    }

    /**
     * 批量删除策略分配
     *
     * @param {number[]} assignmentIds - 分配ID数组
     * @returns {Promise<Object>} 批量删除结果
     */
    async batchDeleteAssignments(assignmentIds) {
        return await this.post('/strategy-assignment/batch-delete', { ids: assignmentIds });
    }

    /**
     * 更新策略分配状态
     *
     * @param {Object} data - 更新数据
     * @param {number} data.id - 分配ID
     * @param {number} data.status - 新状态（1-启用，0-禁用）
     * @returns {Promise<Object>} 更新结果
     */
    async updateAssignmentStatus(data) {
        return await this.post('/strategy-assignment/update-status', data);
    }

    // 策略区域定价API（新界面支持）
    async getStrategyAreaPricingList(query = {}) {
        return await this.post('/strategy-area-pricing/list', query);
    }

    async addStrategyAreaPricing(pricingData) {
        return await this.post('/strategy-area-pricing/add', pricingData);
    }

    async addStrategyAreaPricingBatch(batchPricingData) {
        return await this.post('/strategy-area-pricing/batch-add', batchPricingData);
    }

    async updateStrategyAreaPricing(pricingData) {
        return await this.post('/strategy-area-pricing/update', pricingData);
    }

    async deleteStrategyAreaPricing(id) {
        return await this.post('/strategy-area-pricing/delete', { id });
    }

    async deleteStrategyAreaPricingBatch(ids) {
        return await this.post('/strategy-area-pricing/batch-delete', ids);
    }

    // 新界面专用API
    async getStrategyAreaDetails(strategyId, areaIds = null) {
        const url = areaIds ?
            `/strategy-area-pricing/strategy/${strategyId}/area-details?areaIds=${areaIds.join(',')}` :
            `/strategy-area-pricing/strategy/${strategyId}/area-details`;
        return await this.get(url);
    }

    async getStrategyAreaDetail(strategyId, areaId) {
        return await this.get(`/strategy-area-pricing/strategy/${strategyId}/area/${areaId}/detail`);
    }

    async saveStrategyAreaCompleteConfig(configData) {
        return await this.post('/strategy-area-pricing/complete-config/save', configData);
    }

    async saveStrategyAreaCompleteConfigBatch(configDataList) {
        return await this.post('/strategy-area-pricing/complete-config/batch-save', configDataList);
    }

    async enableStrategyAreaPricing(id) {
        return await this.post('/strategy-area-pricing/enable', { id });
    }

    async disableStrategyAreaPricing(id) {
        return await this.post('/strategy-area-pricing/disable', { id });
    }

    async updateStrategyAreaPricingStatus(ids, status) {
        return await this.post(`/strategy-area-pricing/batch-status-update?status=${status}`, { ids });
    }

    async validateStrategyAreaPricing(pricingData) {
        return await this.post('/strategy-area-pricing/validate', pricingData);
    }

    async checkStrategyAreaExists(strategyId, areaId, excludeId = null) {
        const url = excludeId ?
            `/strategy-area-pricing/check-exists?strategyId=${strategyId}&areaId=${areaId}&excludeId=${excludeId}` :
            `/strategy-area-pricing/check-exists?strategyId=${strategyId}&areaId=${areaId}`;
        return await this.get(url);
    }

    async getUnconfiguredAreas(strategyId, level = null) {
        const url = level ?
            `/strategy-area-pricing/strategy/${strategyId}/unconfigured-areas?level=${level}` :
            `/strategy-area-pricing/strategy/${strategyId}/unconfigured-areas`;
        return await this.get(url);
    }

    async getStrategyAreaCoverageStats(strategyId) {
        return await this.get(`/strategy-area-pricing/strategy/${strategyId}/coverage-stats`);
    }

    // ==========================================
    // V3版本定价配置管理API
    // ==========================================

    /**
     * 添加定价配置（V3版本）
     *
     * V3版本相比V2版本的主要变化：
     * - 删除areaId字段，支持多区域关联
     * - 新增name和description必填字段
     * - 定价配置与区域关联分离为独立的映射管理
     *
     * @param {Object} pricingData - 定价配置数据
     * @param {number} pricingData.strategyId - 策略ID
     * @param {string} pricingData.name - 配置名称（V3新增必填字段）
     * @param {string} [pricingData.description] - 配置描述（V3新增字段）
     * @param {number} pricingData.firstWeightKg - 首重重量（kg）
     * @param {number} pricingData.firstWeightFee - 首重资费（元）
     * @param {number} pricingData.additionalWeightKg - 续重重量（kg）
     * @param {number} pricingData.additionalWeightFee - 续重资费（元）
     * @param {number} pricingData.volumetricWeightRatio - 抛重比
     * @param {number} [pricingData.status=1] - 状态（1-启用，0-禁用）
     * @param {string} [pricingData.operator='frontend_user'] - 操作人
     * @returns {Promise<Object>} 新增结果，包含配置ID
     *
     * @example
     * // 创建新的定价配置
     * const result = await api.addPricingConfig({
     *     strategyId: 1,
     *     name: '北京地区定价配置',
     *     description: '适用于北京市区的运费定价',
     *     firstWeightKg: 1.0,
     *     firstWeightFee: 8.00,
     *     additionalWeightKg: 0.5,
     *     additionalWeightFee: 2.00,
     *     volumetricWeightRatio: 5000
     * });
     */
    async addPricingConfig(pricingData) {
        // V3版本请求体结构
        const v3RequestBody = {
            strategyId: pricingData.strategyId,
            name: pricingData.name || `配置名称-${Date.now() % 10000}`, // V3新增必填字段
            description: pricingData.description || '默认定价配置', // V3新增字段
            firstWeightKg: pricingData.firstWeightKg,
            firstWeightFee: pricingData.firstWeightFee,
            additionalWeightKg: pricingData.additionalWeightKg,
            additionalWeightFee: pricingData.additionalWeightFee,
            volumetricWeightRatio: pricingData.volumetricWeightRatio,
            status: pricingData.status || 1,
            operator: pricingData.operator || 'frontend_user'
        };

        return await this.post('/api/pricing-config/add', v3RequestBody);
    }

    /**
     * 更新定价配置（V3版本）
     *
     * @param {Object} pricingData - 定价配置数据
     * @param {number} pricingData.id - 配置ID
     * @param {number} pricingData.strategyId - 策略ID
     * @param {string} pricingData.name - 配置名称（V3必填）
     * @param {string} [pricingData.description] - 配置描述
     * @param {number} pricingData.firstWeightKg - 首重重量
     * @param {number} pricingData.firstWeightFee - 首重资费
     * @param {number} pricingData.additionalWeightKg - 续重重量
     * @param {number} pricingData.additionalWeightFee - 续重资费
     * @param {number} pricingData.volumetricWeightRatio - 抛重比
     * @param {number} pricingData.status - 状态
     * @param {string} [pricingData.operator='frontend_user'] - 操作人
     * @returns {Promise<Object>} 更新结果
     */
    async updatePricingConfig(pricingData) {
        const v3RequestBody = {
            id: pricingData.id,
            strategyId: pricingData.strategyId,
            name: pricingData.name, // V3版本必填
            description: pricingData.description,
            firstWeightKg: pricingData.firstWeightKg,
            firstWeightFee: pricingData.firstWeightFee,
            additionalWeightKg: pricingData.additionalWeightKg,
            additionalWeightFee: pricingData.additionalWeightFee,
            volumetricWeightRatio: pricingData.volumetricWeightRatio,
            status: pricingData.status,
            operator: pricingData.operator || 'frontend_user'
        };

        return await this.post('/api/pricing-config/update', v3RequestBody);
    }

    /**
     * 删除定价配置（V3版本）
     *
     * @param {number} id - 配置ID
     * @returns {Promise<Object>} 删除结果
     */
    async deletePricingConfig(id) {
        return await this.post('/api/pricing-config/delete', { id });
    }

    /**
     * 获取定价配置详情（V3版本）
     *
     * @param {number} pricingId - 配置ID
     * @returns {Promise<Object>} 配置详情
     */
    async getPricingConfigDetail(pricingId) {
        return await this.get(`/api/pricing-config/detail/${pricingId}`);
    }

    // ==========================================
    // V3版本定价区域映射管理API
    // ==========================================

    /**
     * 批量添加定价区域映射（V3版本）
     *
     * 用于将定价配置与多个区域进行关联。V3版本中定价配置与区域的关联
     * 通过独立的映射表管理，支持一个定价配置关联多个区域。
     *
     * @param {number} pricingId - 定价配置ID
     * @param {number[]} areaIds - 区域ID数组
     * @param {string} [operator='frontend_user'] - 操作人
     * @returns {Promise<Object>} 批量添加结果
     *
     * @example
     * // 为定价配置关联多个区域
     * const result = await api.batchAddPricingAreaMapping(123, [1, 2, 3], 'admin');
     */
    async batchAddPricingAreaMapping(pricingId, areaIds, operator = 'frontend_user') {
        return await this.post('/api/pricing-area-mapping/batch-add', {
            pricingId,
            areaIds,
            operator
        });
    }

    /**
     * 批量删除定价区域映射（V3版本）
     *
     * @param {number} pricingId - 定价配置ID
     * @param {number[]} areaIds - 要删除关联的区域ID数组
     * @param {string} [operator='frontend_user'] - 操作人
     * @returns {Promise<Object>} 批量删除结果
     */
    async batchDeletePricingAreaMapping(pricingId, areaIds, operator = 'frontend_user') {
        return await this.post('/api/pricing-area-mapping/batch-delete', {
            pricingId,
            areaIds,
            operator
        });
    }

    /**
     * 查询定价配置关联的区域列表（V3版本）
     *
     * @param {number} pricingId - 定价配置ID
     * @returns {Promise<Object>} 关联的区域ID数组
     */
    async getAreasByPricingId(pricingId) {
        return await this.post(`/api/pricing-area-mapping/areas/${pricingId}`);
    }

    /**
     * 查询区域关联的定价配置列表（V3版本）
     *
     * @param {number} areaId - 区域ID
     * @returns {Promise<Object>} 关联的定价配置列表
     */
    async getPricingsByAreaId(areaId) {
        return await this.post(`/api/pricing-area-mapping/pricings/${areaId}`);
    }

    /**
     * 重新设置定价配置的区域关联（V3版本）
     *
     * 该方法会先清除定价配置的所有现有区域关联，然后重新建立新的关联关系。
     * 适用于需要完全替换区域关联的场景。
     *
     * @param {number} pricingId - 定价配置ID
     * @param {number[]} areaIds - 新的区域ID数组
     * @param {string} [operator='frontend_user'] - 操作人
     * @returns {Promise<Object>} 重设结果
     *
     * @example
     * // 将定价配置的区域关联完全替换为新的区域列表
     * const result = await api.resetPricingAreaMapping(123, [4, 5, 6], 'admin');
     */
    async resetPricingAreaMapping(pricingId, areaIds, operator = 'frontend_user') {
        return await this.post(`/api/pricing-area-mapping/reset/${pricingId}?operator=${operator}`, areaIds);
    }

    /**
     * 检查定价配置与区域是否已关联（V3版本）
     *
     * @param {number} pricingId - 定价配置ID
     * @param {number} areaId - 区域ID
     * @returns {Promise<Object>} 关联检查结果
     */
    async checkPricingAreaMapping(pricingId, areaId) {
        return await this.post(`/api/pricing-area-mapping/check/${pricingId}/${areaId}`);
    }

    // ==========================================
    // V3版本高级功能API
    // ==========================================

    /**
     * 创建定价配置并关联区域（V3版本组合操作）
     *
     * 这是一个高级封装方法，将定价配置创建和区域关联合并为一个原子操作。
     * 如果任一步骤失败，会尝试回滚已执行的操作。
     *
     * @param {Object} formData - 表单数据
     * @param {number} formData.strategyId - 策略ID
     * @param {string} formData.name - 配置名称
     * @param {string} [formData.description] - 配置描述
     * @param {number[]} [formData.areaIds] - 要关联的区域ID数组
     * @param {number} formData.firstWeightKg - 首重重量
     * @param {number} formData.firstWeightFee - 首重资费
     * @param {number} formData.additionalWeightKg - 续重重量
     * @param {number} formData.additionalWeightFee - 续重资费
     * @param {number} formData.volumetricWeightRatio - 抛重比
     * @param {string} [formData.operator='frontend_user'] - 操作人
     * @returns {Promise<Object>} 操作结果，包含创建的配置ID
     */
    async createPricingConfigWithAreas(formData) {
        try {
            // 第一步：创建定价配置（V3版本不再直接关联区域）
            const pricingResponse = await this.addPricingConfig({
                strategyId: formData.strategyId,
                name: formData.name || `配置名称-${Date.now() % 10000}`,
                description: formData.description || '',
                firstWeightKg: formData.firstWeightKg,
                firstWeightFee: formData.firstWeightFee,
                additionalWeightKg: formData.additionalWeightKg,
                additionalWeightFee: formData.additionalWeightFee,
                volumetricWeightRatio: formData.volumetricWeightRatio,
                operator: formData.operator || 'frontend_user'
            });

            const pricingId = pricingResponse.data.id;

            // 第二步：关联区域（V3版本新增步骤）
            if (formData.areaIds && formData.areaIds.length > 0) {
                await this.batchAddPricingAreaMapping(
                    pricingId,
                    formData.areaIds,
                    formData.operator || 'frontend_user'
                );
            }

            return { success: true, pricingId };
        } catch (error) {
            console.error('创建定价配置失败:', error);
            return { success: false, error };
        }
    }

    /**
     * 更新定价配置和区域关联（V3版本组合操作）
     *
     * @param {Object} formData - 表单数据
     * @param {number} formData.id - 配置ID
     * @param {number[]} [formData.areaIds] - 新的区域ID数组
     * @returns {Promise<Object>} 操作结果
     */
    async updatePricingConfigWithAreas(formData) {
        try {
            // 第一步：更新定价配置
            await this.updatePricingConfig(formData);

            // 第二步：重新设置区域关联
            if (formData.areaIds) {
                await this.resetPricingAreaMapping(
                    formData.id,
                    formData.areaIds,
                    formData.operator || 'frontend_user'
                );
            }

            return { success: true };
        } catch (error) {
            console.error('更新定价配置失败:', error);
            return { success: false, error };
        }
    }

    /**
     * 查询定价配置详情（包含关联的区域）
     *
     * @param {number} pricingId - 定价配置ID
     * @returns {Promise<Object|null>} 配置详情，包含areaIds字段
     */
    async getPricingConfigDetailWithAreas(pricingId) {
        try {
            // 查询定价配置基本信息
            const pricingResponse = await this.getPricingConfigDetail(pricingId);
            const pricingData = pricingResponse.data;

            // 查询关联的区域
            const areasResponse = await this.getAreasByPricingId(pricingId);
            const areaIds = areasResponse.data;

            return {
                ...pricingData,
                areaIds: areaIds || []
            };
        } catch (error) {
            console.error('查询定价配置详情失败:', error);
            return null;
        }
    }

    // ==========================================
    // 操作日志API
    // ==========================================

    /**
     * 获取操作日志统计信息
     *
     * 返回今日操作数、成功操作数、失败操作数和总操作数等统计数据。
     *
     * @returns {Promise<Object>} 统计信息对象
     * @returns {number} returns.data.todayCount - 今日操作数
     * @returns {number} returns.data.successCount - 成功操作数
     * @returns {number} returns.data.errorCount - 失败操作数
     * @returns {number} returns.data.totalCount - 总操作数
     *
     * @example
     * const stats = await api.getOperationLogStatistics();
     * console.log('今日操作:', stats.data.todayCount);
     */
    async getOperationLogStatistics() {
        return await this.post('/operation-log/statistics/detailed');
    }

    /**
     * 获取操作日志列表（分页）
     *
     * 支持按模块类型、操作类型、操作人、状态等条件进行筛选查询。
     *
     * @param {Object} [query={}] - 查询条件
     * @param {number} [query.currentPage=1] - 当前页码
     * @param {number} [query.pageSize=10] - 每页数量
     * @param {string} [query.moduleType] - 模块类型（AREA、FREIGHT_STRATEGY等）
     * @param {string} [query.operationType] - 操作类型（INSERT、UPDATE、DELETE等）
     * @param {string} [query.operator] - 操作人
     * @param {number} [query.status] - 操作状态（1-成功，2-失败）
     * @param {string} [query.businessName] - 业务名称（模糊查询）
     * @param {string} [query.traceId] - 链路追踪ID
     * @returns {Promise<Object>} 分页日志数据
     *
     * @example
     * // 获取第一页数据
     * const logs = await api.getOperationLogList({ currentPage: 1, pageSize: 20 });
     *
     * // 按条件筛选
     * const logs = await api.getOperationLogList({
     *   moduleType: 'AREA',
     *   operationType: 'INSERT',
     *   status: 1
     * });
     */
    async getOperationLogList(query = {}) {
        return await this.post('/operation-log/list', query);
    }

    /**
     * 获取操作日志详情
     *
     * 根据日志ID获取完整的操作日志详情信息，包括请求参数、
     * 响应结果、操作前后数据、变更字段等。
     *
     * @param {number} logId - 日志ID（主键）
     * @returns {Promise<Object>} 日志详情数据
     *
     * @example
     * const detail = await api.getOperationLogDetail(1001);
     * console.log('操作详情:', detail.data);
     */
    async getOperationLogDetail(logId) {
        return await this.post(`/operation-log/detail/${logId}`);
    }

    /**
     * 获取最近的操作日志
     *
     * 用于显示最近的操作记录，按操作时间倒序排列。
     *
     * @param {number} [limit=20] - 返回记录数量限制
     * @returns {Promise<Object>} 最近操作日志列表
     *
     * @example
     * // 获取最近10条操作记录
     * const recentLogs = await api.getRecentOperationLogs(10);
     */
    async getRecentOperationLogs(limit = 20) {
        return await this.post(`/operation-log/recent?limit=${limit}`);
    }

    // ==========================================
    // V3策略配置统一管理API (补充缺失的方法)
    // ==========================================

    /**
     * V3策略配置保存（统一接口）
     *
     * 用于V3版本的策略配置统一保存，支持策略基本信息、重量规则、区域配置的一次性提交。
     *
     * @param {Object} configData - 完整的策略配置数据
     * @param {Object} configData.strategy - 策略基本信息
     * @param {Array} configData.weightRules - 重量区间规则数组
     * @param {Array} configData.areaConfigs - 区域定价配置数组
     * @returns {Promise<Object>} 保存结果
     */
    async saveV3StrategyConfiguration(configData) {
        return await this.post('/v3/strategy-configuration/save', configData);
    }

    /**
     * 策略区域定价统一保存（V3界面专用）
     *
     * @param {Object} configData - 区域配置数据
     * @returns {Promise<Object>} 保存结果
     */
    async saveStrategyAreaAllConfig(configData) {
        return await this.post('/strategy-area-pricing/save-all-config', configData);
    }

    /**
     * 批量保存策略区域完整配置
     *
     * @param {Array} configDataList - 配置数据数组
     * @returns {Promise<Object>} 保存结果
     */
    async batchSaveStrategyAreaCompleteConfig(configDataList) {
        return await this.post('/strategy-area-pricing/complete-config/batch-save', configDataList);
    }

    // ==========================================
    // 系统管理和工具API
    // ==========================================

    /**
     * 健康检查API
     *
     * 用于检查后端服务的可用性和响应状态。
     *
     * @returns {Promise<Object>} 健康状态信息
     */
    async healthCheck() {
        return await this.get('/actuator/health');
    }

    /**
     * 获取系统信息
     *
     * @returns {Promise<Object>} 系统信息
     */
    async getSystemInfo() {
        return await this.get('/actuator/info');
    }

    /**
     * 清理缓存
     *
     * @param {string} [cacheType='all'] - 缓存类型
     * @returns {Promise<Object>} 清理结果
     */
    async clearCache(cacheType = 'all') {
        return await this.post('/system/cache/clear', { cacheType });
    }
}

// ==========================================
// 全局API实例创建和验证
// ==========================================

/**
 * 创建全局API服务实例
 *
 * 该实例使用'/freight'作为基础URL，与后端接口前缀保持一致。
 * 全局单例模式，确保整个应用使用同一个API服务实例。
 *
 * @type {ApiService}
 * @readonly
 */
// 创建全局API服务实例并暴露到全局
// 延迟创建，等待axios加载完成
let api = null;

/**
 * 创建或获取API实例
 * 延迟初始化，确保axios已加载
 */
function createApiInstance() {
    if (api) return api;

    if (typeof axios === 'undefined') {
        console.warn('⚠️ axios尚未加载，稍后重试...');
        return null;
    }

    try {
        api = new window.ApiService('/freight');
        window.api = api;
        console.log('✅ API实例创建成功，baseURL:', api.baseURL);
        return api;
    } catch (error) {
        console.error('❌ API实例创建失败:', error);
        return null;
    }
}

// 获取API实例（延迟创建）
function getApiInstance() {
    if (!api) {
        api = createApiInstance();
    }
    return api;
}

// 带重试机制的API实例获取
function getApiInstanceWithRetry(maxRetries = 5, delay = 100) {
    return new Promise((resolve) => {
        let retries = 0;

        const tryGetApi = () => {
            const apiInstance = getApiInstance();
            if (apiInstance) {
                resolve(apiInstance);
                return;
            }

            if (retries < maxRetries) {
                retries++;
                console.log(`🔄 API实例获取重试 ${retries}/${maxRetries}`);
                setTimeout(tryGetApi, delay);
            } else {
                console.error('❌ API实例获取失败，已达到最大重试次数');
                resolve(null);
            }
        };

        tryGetApi();
    });
}

// 暴露到全局
window.getApiInstance = getApiInstance;
window.createApiInstance = createApiInstance;
window.getApiInstanceWithRetry = getApiInstanceWithRetry;

// ==========================================
// 调试和验证信息
// ==========================================

// 调试信息：确认API实例创建成功
// 延迟初始化，在需要时才创建
setTimeout(() => {
    const apiInstance = getApiInstance();
    if (apiInstance) {
        console.log('🔧 API实例已创建:', apiInstance);
        console.log('🔧 API实例类型:', typeof apiInstance);
        console.log('🔧 API构造函数名:', apiInstance.constructor.name);
        // console.log('🔧 API可用方法:', Object.getOwnPropertyNames(Object.getPrototypeOf(apiInstance)).filter(name => typeof apiInstance[name] === 'function'));
    } else {
        console.warn('⚠️ API实例尚未创建，等待axios加载...');
    }
}, 100);

/**
 * 验证关键方法的可用性
 *
 * 检查所有核心API方法是否正确加载，确保系统功能完整性。
 */
setTimeout(() => {
    const apiInstance = getApiInstance();
    if (!apiInstance) {
        console.warn('⚠️ API实例尚未创建，跳过方法验证');
        return;
    }

    const criticalMethods = [
        // 基础HTTP方法
        'get', 'post', 'put', 'delete',
        // 重量规则管理
        'addWeightRule', 'updateWeightRule', 'deleteWeightRule',
        // 操作日志管理
        'getOperationLogStatistics', 'getOperationLogList', 'getOperationLogDetail'
    ];

    criticalMethods.forEach(method => {
        if (apiInstance[method]) {
            console.log(`✅ ${method} 方法可用`);
        } else {
            console.error(`❌ ${method} 方法缺失`);
        }
    });
}, 200);

// ==========================================
// 全局API初始化系统
// ==========================================

/**
 * 全局API初始化系统
 *
 * 该系统确保在不同模块中都能一致地访问API服务实例。
 * 支持多种获取方式以适应不同的模块系统和加载环境。
 *
 * @class GlobalApiManager
 */
class GlobalApiManager {
    constructor() {
        this.apiInstance = null; // 延迟初始化
        this.isInitialized = false;
        this.initCallbacks = [];
    }

    /**
     * 初始化全局API管理器
     */
    initialize() {
        if (this.isInitialized) {
            return;
        }

        // 获取或创建API实例
        this.apiInstance = getApiInstance();
        if (!this.apiInstance) {
            console.warn('⚠️ API实例尚未就绪，稍后重试...');
            setTimeout(() => this.initialize(), 100);
            return;
        }

        // 将API实例挂载到全局对象
        if (typeof window !== 'undefined') {
            window.FreightAPI = this.apiInstance;
            window.globalApi = this.apiInstance; // 兼容性别名

            // 为Vue应用提供访问
            if (window.vueAppInstance) {
                window.vueAppInstance.api = this.apiInstance;
            }

            console.log('✅ 全局API实例已挂载到 window.FreightAPI');
        }

        // 为 CommonJS 环境提供支持
        if (typeof global !== 'undefined') {
            global.FreightAPI = this.apiInstance;
        }

        this.isInitialized = true;

        // 执行初始化回调
        this.initCallbacks.forEach(callback => {
            try {
                callback(this.apiInstance);
            } catch (error) {
                console.error('初始化回调执行失败:', error);
            }
        });
        this.initCallbacks = [];

        console.log('✅ 全局API管理器初始化完成');

        // 执行诊断检查
        this.performDiagnostics();
    }

    /**
     * 执行系统诊断
     */
    performDiagnostics() {
        console.group('🔍 API系统诊断');

        // 检查axios
        if (typeof axios !== 'undefined') {
            console.log('✅ axios库已加载');
        } else {
            console.error('❌ axios库未加载');
        }

        // 检查API实例
        if (this.apiInstance) {
            console.log('✅ API实例已创建');
            console.log('🔧 API基础URL:', this.apiInstance.baseURL);

            // 检查关键方法
            const keyMethods = ['get', 'post', 'getOperationLogStatistics', 'getOperationLogList'];
            keyMethods.forEach(method => {
                if (typeof this.apiInstance[method] === 'function') {
                    console.log(`✅ ${method} 方法可用`);
                } else {
                    console.error(`❌ ${method} 方法缺失`);
                }
            });
        } else {
            console.error('❌ API实例未创建');
        }

        console.groupEnd();
    }

    /**
     * 注册初始化回调
     *
     * @param {Function} callback - 初始化完成后的回调函数
     */
    onInitialized(callback) {
        if (this.isInitialized) {
            callback(this.apiInstance);
        } else {
            this.initCallbacks.push(callback);
        }
    }

    /**
     * 获取API实例
     *
     * @returns {ApiService} API服务实例
     */
    getApiInstance() {
        return this.apiInstance;
    }

    /**
     * 检查API实例的可用性
     *
     * @returns {Promise<boolean>} 是否可用
     */
    async checkHealth() {
        try {
            await this.apiInstance.healthCheck();
            return true;
        } catch (error) {
            console.warn('API健康检查失败:', error.message);
            return false;
        }
    }
}

// 创建全局管理器实例
// 创建全局管理器实例并暴露到全局
const globalApiManager = new GlobalApiManager();
window.globalApiManager = globalApiManager;

/**
 * 获取全局API实例的工具函数
 *
 * 该函数提供多种获取API实例的方式，确保在不同环境下都能正常工作。
 * 优先级顺序：直接导入 > 全局对象 > Vue实例 > 管理器获取
 *
 * @returns {ApiService|null} API服务实例或null
 *
 * @example
 * // 在其他模块中使用
 * const apiInstance = getGlobalApiInstance();
 * if (apiInstance) {
 *     const areas = await apiInstance.getAreas();
 * }
 */
// 获取全局API实例的工具函数并暴露到全局
function getGlobalApiInstance() {
    // 方法 1：直接返回导出的实例
    const apiInstance = getApiInstance();
    if (apiInstance && typeof apiInstance.request === 'function') {
        return apiInstance;
    }

    // 方法 2：从全局对象获取
    if (typeof window !== 'undefined') {
        if (window.FreightAPI && typeof window.FreightAPI.request === 'function') {
            return window.FreightAPI;
        }
        if (window.globalApi && typeof window.globalApi.request === 'function') {
            return window.globalApi;
        }
    }

    // 方法 3：从Vue应用实例获取
    if (typeof window !== 'undefined' && window.vueAppInstance && window.vueAppInstance.api) {
        return window.vueAppInstance.api;
    }

    // 方法 4：从全局管理器获取
    if (globalApiManager && typeof globalApiManager.getApiInstance === 'function') {
        return globalApiManager.getApiInstance();
    }

    console.warn('⚠️ 无法获取全局API实例');
    return null;
}

/**
 * 等待API初始化完成
 *
 * @returns {Promise<ApiService>} API服务实例
 */
// 等待API初始化完成的函数并暴露到全局
function waitForApiInitialization() {
    return new Promise((resolve, reject) => {
        const apiInstance = getGlobalApiInstance();
        if (apiInstance) {
            resolve(apiInstance);
            return;
        }

        // 等待初始化
        globalApiManager.onInitialized((instance) => {
            resolve(instance);
        });

        // 超时处理
        setTimeout(() => {
            reject(new Error('API初始化超时'));
        }, 5000);
    });
}

// 自动初始化全局API管理器
if (typeof window !== 'undefined') {
    // 立即尝试初始化（不等待DOM）
    setTimeout(() => {
        try {
            globalApiManager.initialize();
        } catch (error) {
            console.warn('⚠️ API管理器初始化失败，将在DOM加载后重试:', error.message);
        }
    }, 0);

    // 在DOM加载完成后再次尝试（如果之前失败）
    if (document.readyState === 'loading') {
        document.addEventListener('DOMContentLoaded', () => {
            if (!globalApiManager.isInitialized) {
                globalApiManager.initialize();
            }
        });
    }
} else {
    // 非DOM环境（如Node.js）直接初始化
    globalApiManager.initialize();
}

// 暴露主要函数到全局作用域
if (typeof window !== 'undefined') {
    window.getGlobalApiInstance = getGlobalApiInstance;
    window.waitForApiInitialization = waitForApiInitialization;

    // 为了支持ES6 import语法，在全局范围内提供导出
    window.__ES6_EXPORTS__ = window.__ES6_EXPORTS__ || {};
    window.__ES6_EXPORTS__['./api.js'] = {
        get default() { return getApiInstance(); },
        get api() { return getApiInstance(); },
        ApiService: window.ApiService,
        globalApiManager: globalApiManager,
        getGlobalApiInstance: getGlobalApiInstance,
        waitForApiInitialization: waitForApiInitialization,
        createApiInstance: createApiInstance,
        getApiInstance: getApiInstance
    };

    console.log('✅ API模块已暴露到全局作用域和ES6导出');
}
